#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
评教点击器
在检测到"已成功导航到评教页面"日志后，自动点击未评价课程的"评价"链接
"""

import os
import sys
import time
import logging
from typing import List, Dict, Any, Optional
import re
import json

# 添加项目根目录到路径，确保能正确导入模块
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

# 设置日志 - 简化日志配置，防止重复
logger = logging.getLogger(__name__)
# 检查是否已经有处理器，避免重复添加
if not logger.handlers:
    logger.setLevel(logging.INFO)
    # 不添加额外的处理器，使用根日志的配置

class EvaluationClicker:
    """
    评教点击器
    自动查找并点击评教页面中的"评价"链接
    """
    
    def __init__(self, page=None):
        """
        初始化评教点击器
        
        Args:
            page: DrissionPage页面对象
        """
        self.page = page
        self.clicked_courses = set()  # 记录已经点击过的课程
    
    def set_page(self, page):
        """
        设置页面对象
        
        Args:
            page: DrissionPage页面对象
        """
        self.page = page
    
    def click_evaluation_button(self) -> bool:
        """
        查找并点击"评价"按钮
        只点击对应的评价链接，确保不点击"未评价"文本
        
        Returns:
            bool: 是否成功点击
        """
        if not self.page:
            logger.error("未设置页面对象")
            return False
        
        try:
            # 保存原始URL，用于验证是否成功导航
            original_url = self.page.url
            
            
            # 刷新页面以获取最新状态
            logger.info("刷新页面获取最新状态")
            self.page.refresh()
            time.sleep(0.4)  # 等待400毫秒
            
            logger.info("开始查找评价按钮")
            
            # 初始化精确匹配"评价"文本的链接
            exact_eval_links = self.page.eles('xpath://a[text()="评价"]')
            
            if exact_eval_links:
                logger.info(f"找到 {len(exact_eval_links)} 个精确匹配'评价'文本的链接")
                evaluation_links = exact_eval_links
            else:
                logger.info("未找到精确匹配的评价链接，尝试模糊匹配")
                # 修复: 使用更安全的方式查找和处理链接
                all_links = self.page.eles('css:a')
                evaluation_links = []
                
                for link in all_links:
                    try:
                        # 安全获取链接文本
                        link_text = ""
                        try:
                            # 使用JS获取文本，避免属性错误
                            link_text = self.page.run_js("return arguments[0].textContent || arguments[0].innerText || '';", link).strip()
                        except:
                            # 如果JS失败，尝试其他方法
                            if hasattr(link, 'text'):
                                link_text = link.text.strip()
                            elif hasattr(link, 'inner_text'):
                                link_text = link.inner_text.strip()
                        
                        if link_text == "评价":
                            evaluation_links.append(link)
                            logger.info(f"找到评价链接: '{link_text}'")
                    except Exception as e:
                        logger.error(f"处理链接时出错: {e}")
                        continue
            
            logger.info(f"总共找到 {len(evaluation_links)} 个可能的评价链接")
            
            # 过滤已评价的课程行，只保留未评价的
            filtered_links = []
            for link in evaluation_links:
                row = self.get_parent_element(link, 'tr')
                if row:
                    row_text = row.text
                    course_info = self.extract_course_info(row)
                    course_id = f"{course_info.get('课程名称', '')}-{course_info.get('教师姓名', '')}"
                    
                    # 检查课程状态
                    if "未评价" in row_text and course_id not in self.clicked_courses:
                        filtered_links.append(link)
                        logger.info(f"找到未评价课程: {course_id}")
                    else:
                        logger.info(f"跳过课程: {course_id} (已评价或已处理)")
            
            logger.info(f"过滤后保留 {len(filtered_links)} 个未评价课程的链接")
            
            if not filtered_links:
                logger.info("未找到更多评价按钮，评价任务已全部完成")
                # 添加回退页面的逻辑
                try:
                    # 查找并点击"返回"按钮
                    back_button = self.page.ele('css:a:contains("返回"), button:contains("返回")')
                    if back_button:
                        logger.info("找到返回按钮，准备点击")
                        back_button.click()
                        time.sleep(0.8)  # 等待页面响应，改为800毫秒
                        logger.info("已点击返回按钮")
                    else:
                        # 如果没有找到返回按钮，尝试使用浏览器的后退功能
                        logger.info("未找到返回按钮，尝试使用浏览器后退功能")
                        self.page.back()
                        time.sleep(0.8)  # 等待800毫秒
                        logger.info("已执行浏览器后退操作")
                except Exception as e:
                    logger.error(f"执行返回操作时发生异常: {e}")
                return False
            
            # 使用过滤后的链接
            evaluation_links = filtered_links

            # 遍历找到的评价链接
            for link in evaluation_links:
                # 尝试最多3次点击操作
                for attempt in range(3):
                    try:
                        link_text = link.text.strip()
                        onclick_attr = link.attr('onclick')
                        
                        logger.info(f"尝试点击评价链接: '{link_text}'，第{attempt+1}次尝试")
                        
                        # 获取课程信息
                        row = self.get_parent_element(link, 'tr')
                        course_info = self.extract_course_info(row) if row else {"课程名称": "未知课程", "教师姓名": "未知教师"}
                        course_id = f"{course_info.get('课程名称', '未知课程')}-{course_info.get('教师姓名', '未知教师')}"
                        
                        # 检查是否已经点击过
                        if course_id in self.clicked_courses:
                            logger.info(f"课程 '{course_id}' 已点击过，跳过")
                            break
                        
                        # 处理具有onclick属性的链接
                        if onclick_attr:
                            result = self._process_onclick_button(link, onclick_attr)
                            if result:
                                logger.info(f"成功通过onclick属性处理评价链接: {course_id}")
                                return True
                        else:
                            # 直接点击链接
                            link.click()
                            logger.info("点击后等待400毫秒...")
                            time.sleep(0.4)  # 等待页面加载，改为400毫秒
                            
                            # 检查页面是否发生变化
                            current_url = self.page.url
                            if current_url != original_url:
                                logger.info("成功导航到新页面")
                                self.clicked_courses.add(course_id)
                                
                                # 检查页面是否有评教表单
                                if self.page.ele('css:form') or self.page.ele('css:.radio'):
                                    logger.info("检测到评教表单，准备进行评教")
                                    return True
                                else:
                                    logger.warning("未检测到评教表单，可能导航不完整")
                                    
                            # 如果未成功导航，延迟后重试
                            logger.warning("点击后页面未发生预期变化")
                            logger.info("等待400毫秒后重试...")
                            time.sleep(0.4)  # 固定延迟，改为400毫秒
                        
                    except Exception as click_error:
                        logger.error(f"点击评价链接时出错: {click_error}，尝试第{attempt+1}次")
                        logger.info("出错后等待400毫秒...")
                        time.sleep(0.4)  # 固定延迟，改为400毫秒
            
            logger.warning("尝试所有评价链接后仍未成功导航到评教页面")
            return False
            
        except Exception as e:
            logger.error(f"点击评价按钮时发生异常: {e}")
            return False
    
    def find_green_eval_buttons(self) -> List:
        """
        查找绿色(#00ABA1)背景的评价按钮 - 已废弃，保留为兼容性考虑
        
        Returns:
            List: 按钮元素列表
        """
        # 返回空列表，不再使用颜色检测
        logger.info("颜色检测功能已禁用")
        return []
    
    def extract_course_info(self, row_element) -> Dict[str, str]:
        """
        从行元素中提取课程信息
        
        Args:
            row_element: 行元素
            
        Returns:
            Dict[str, str]: 课程信息字典
        """
        course_info = {
            "课程名称": "",
            "课程代码": "",
            "课程类型": "",
            "教师姓名": "",
            "评价状态": ""
        }
        
        try:
            # 获取所有单元格
            cells = row_element.eles('tag:td')
            
            if len(cells) >= 3:
                # 提取课程名称和代码
                course_cell = cells[0]
                course_text = course_cell.text.strip()
                
                # 移除"未评价"文本
                course_text = course_text.replace("未评价", "").strip()
                
                # 提取课程代码
                code_match = re.search(r'\((\d+.*?)\)', course_text)
                if code_match:
                    course_info["课程代码"] = code_match.group(1)
                    course_name = re.sub(r'\(.*?\)', '', course_text).strip()
                    course_info["课程名称"] = course_name
                else:
                    course_info["课程名称"] = course_text
                
                # 提取课程类型和教师姓名
                if len(cells) > 1:
                    course_info["课程类型"] = cells[1].text.strip()
                
                if len(cells) > 2:
                    course_info["教师姓名"] = cells[2].text.strip()
                
                # 检查评价状态
                for cell in cells:
                    cell_text = cell.text.strip()
                    if "未评价" in cell_text:
                        course_info["评价状态"] = "未评价"
                        break
                    elif "已评价" in cell_text:
                        course_info["评价状态"] = "已评价"
                        break
        
        except Exception as e:
            logger.error(f"提取课程信息时发生异常: {e}")
        
        return course_info

    def _process_onclick_button(self, button, onclick_attr):
        """
        处理带有onclick属性的按钮
        
        Args:
            button: 按钮元素
            onclick_attr: onclick属性值
            
        Returns:
            bool: 是否成功处理
        """
        try:
            # 获取课程信息
            course_info = {}
            course_id = "未知课程"
            
            try:
                # 尝试获取父元素
                # parent_ele方法可能不存在，尝试多种方式获取父元素
                if hasattr(button, 'parent_ele'):
                    row = button.parent_ele('tag:tr')
                    course_info = self.extract_course_info(row)
                elif hasattr(button, 'parent'):
                    row = button.parent('tag:tr')
                    course_info = self.extract_course_info(row)
                else:
                    # 无法获取父元素，尝试从按钮文本中提取信息
                    logger.info("无法获取按钮的父元素，尝试从按钮文本和属性中提取信息")
                    button_text = button.text
                    course_info = {
                        "课程名称": button_text.replace("评价", "").strip() if "评价" in button_text else "未知课程",
                        "教师姓名": "未知教师"
                    }
                    
                    # 尝试从onclick属性中提取更多信息
                    if "jshtck" in onclick_attr or "evaluate" in onclick_attr:
                        # 从onclick中提取课程名称和教师信息
                        matches = re.findall(r"['\"]([^'\"]+)['\"]", onclick_attr)
                        
                        # 尝试查找可能的课程名称（通常是第4个参数，即kcmc参数）
                        if len(matches) > 3:
                            for match in matches:
                                if len(match) > 2 and not match.isdigit() and not match.startswith(('http', 'www')):
                                    course_info["课程名称"] = match
                                    break
            except Exception as row_err:
                logger.error(f"获取按钮父元素时出错: {row_err}")
                # 使用默认值
                course_info = {
                    "课程名称": "未知课程",
                    "教师姓名": "未知教师"
                }
            
            course_id = f"{course_info.get('课程名称', '未知课程')}-{course_info.get('教师姓名', '未知教师')}"
            
            # 检查是否已经点击过
            if course_id in self.clicked_courses:
                logger.info(f"课程 '{course_id}' 已点击过，跳过")
                return False
            
            logger.info(f"处理带onclick属性的评价按钮，课程: {course_id}")
            logger.info(f"按钮onclick属性: {onclick_attr}")
            
            # 解析onclick参数
            params = {}
            if "jshtck" in onclick_attr:
                # 尝试提取jshtck函数的参数
                logger.info("解析jshtck函数参数")
                
                # 正则匹配提取jshtck的参数
                import re
                matches = re.findall(r"['\"]([^'\"]+)['\"]", onclick_attr)
                
                if matches and len(matches) >= 5:
                    params = {
                        "kolc": matches[0] if len(matches) > 0 else "",
                        "实验课": matches[1] if len(matches) > 1 else "",
                        "kch": matches[2] if len(matches) > 2 else "",
                        "kcmc": matches[3] if len(matches) > 3 else "",
                        "xh": matches[4] if len(matches) > 4 else "",
                        "pjjgid": matches[5] if len(matches) > 5 else "",
                        "btn": matches[6] if len(matches) > 6 else ""
                    }
                    logger.info(f"解析到的jshtck参数: {params}")
                    
                    # 从参数中更新课程信息
                    if params.get("kcmc"):
                        course_info["课程名称"] = params["kcmc"]
                        course_id = f"{params['kcmc']}-{course_info.get('教师姓名', '未知教师')}"
            
            elif "evaluate1" in onclick_attr or "evaluate" in onclick_attr:
                # 尝试提取evaluate1函数的参数
                logger.info("解析evaluate函数参数")
                
                # 查找参数数组
                import re
                array_match = re.search(r'\[(.*?)\]', onclick_attr)
                
                if array_match:
                    # 提取数组内容并解析
                    array_content = array_match.group(1)
                    
                    # 尝试解析键值对
                    key_value_pairs = re.findall(r"['\"]([^'\"]*)['\"]\s*:\s*['\"]([^'\"]*)['\"]", array_content)
                    for key, value in key_value_pairs:
                        params[key] = value
                        
                        # 更新课程信息
                        if key == "kcmc":
                            course_info["课程名称"] = value
                        elif key == "xm":
                            course_info["教师姓名"] = value
                    
                    # 更新课程ID
                    if "kcmc" in params:
                        course_id = f"{params['kcmc']}-{params.get('xm', '未知教师')}"
                    
                    # 提取不是键值对的元素
                    non_kv_items = re.findall(r"['\"]([^'\"]*)['\"]\s*(?!:)", array_content)
                    for i, item in enumerate(non_kv_items):
                        params[f"param{i+1}"] = item
                    
                    logger.info(f"解析到的evaluate参数: {params}")
            
            # 点击按钮
            logger.info(f"点击评价按钮，课程: {course_id}")
            button.click()
            
            # 记录已点击
            self.clicked_courses.add(course_id)
            
            # 使用固定等待时间
            logger.info("等待400毫秒...")
            time.sleep(0.4)
            
            # 检查页面是否显示表单
            if self.page.ele('css:form') or self.page.ele('css:.radio'):
                logger.info("成功导航到评教页面，检测到评教表单")
                return True
            else:
                logger.warning("页面未显示评教表单，尝试使用JS执行评教跳转")
                # 尝试使用JS直接执行onclick属性
                try:
                    if params and "jshtck" in onclick_attr:
                        # 构建jshtck函数调用
                        js_func = f"""
                        jshtck(
                            '{params.get("kolc", "")}',
                            '{params.get("实验课", "")}',
                            '{params.get("kch", "")}',
                            '{params.get("kcmc", "")}',
                            '{params.get("xh", "")}',
                            '{params.get("pjjgid", "")}',
                            '{params.get("btn", "")}'
                        );
                        """
                        logger.info(f"尝试直接执行jshtck JS: {js_func}")
                        self.page.run_js(js_func)
                    elif "evaluate" in onclick_attr:
                        # 直接执行原始onclick代码
                        logger.info(f"尝试直接执行原始JS: {onclick_attr}")
                        self.page.run_js(onclick_attr)
                    
                    logger.info("等待400毫秒...")
                    time.sleep(0.4)
                    
                    # 再次检查页面是否有表单
                    if self.page.ele('css:form') or self.page.ele('css:.radio'):
                        logger.info("JS执行后成功导航到评教页面")
                        return True
                except Exception as js_err:
                    logger.error(f"执行JS时出错: {js_err}")
                    
            return False
                
        except Exception as e:
            logger.error(f"处理onclick按钮时发生异常: {e}")
            return False

    def get_parent_element(self, element, tag_name='tr'):
        """
        安全获取元素的父元素
        
        Args:
            element: 元素对象
            tag_name: 父元素的标签名
            
        Returns:
            父元素对象或None
        """
        try:
            # 尝试不同的方法获取父元素
            if hasattr(element, 'parent_ele'):
                return element.parent_ele(f'tag:{tag_name}')
            elif hasattr(element, 'parent'):
                return element.parent(f'tag:{tag_name}')
            elif hasattr(element, 'xpath'):
                # 使用XPath获取父元素
                parent_xpath = f'xpath:./ancestor::{tag_name}[1]'
                return element.xpath(parent_xpath)
            else:
                # 尝试使用JavaScript获取父元素
                js_code = f"""
                function getParentByTagName(element, tagName) {{
                    tagName = tagName.toLowerCase();
                    while (element && element.tagName && element.tagName.toLowerCase() !== tagName) {{
                        element = element.parentElement;
                    }}
                    return element;
                }}
                
                var parent = getParentByTagName(arguments[0], '{tag_name}');
                return parent ? true : false;
                """
                has_parent = self.page.run_js(js_code, element)
                
                if has_parent:
                    # 如果有父元素，需要想办法获取它作为DrissionPage元素
                    logger.info(f"元素有{tag_name}父元素，但无法直接通过Python API获取")
                    return None
                
                return None
        except Exception as e:
            logger.error(f"获取父元素时出错: {e}")
            return None

    def fill_text_areas(self):
        """
        填写文本输入框，如问答题
        
        Returns:
            bool: 是否成功填写
        """
        try:
            # 建议文字池
            suggestions = [
                "增加课堂提问",
                "引入小组讨论",
                "多用案例分析",
                "结合实时投票工具",
                "设计模拟实践任务",
                "精简课程核心目标",
                "更新行业前沿案例",
                "提供课程思维导图",
                "定期匿名反馈问卷",
                "作业批注替代打分",
                "固定时段答疑辅导",
                "用动画解析抽象概念",
                "共享在线学习资源",
                "试行混合教学模式",
                "降低期末考权重",
                "增加过程性评价",
                "开放课题替代笔试",
                "调整课堂节奏松紧",
                "关注沉默学生需求",
                "融入职业发展内容"
            ]
            
            # 满意度问题回答池
            satisfaction_suggestions = [
                "老师讲课清晰有条理，能把复杂概念通俗易懂地讲解",
                "教学内容紧跟学科前沿，案例贴近实际应用",
                "课堂互动频率高，能激发学习兴趣",
                "教学资料丰富，提供了大量扩展阅读材料",
                "课程结构设计合理，难度分布均衡",
                "教师能及时回应学生疑问，提供个性化指导",
                "理论联系实际，学到了实用技能",
                "课堂氛围活跃，学习体验良好",
                "作业设计有创意，能够促进思考",
                "教师授课富有激情，深入浅出"
            ]
            
            # 改进建议回答池
            improvement_suggestions = [
                "希望增加更多实操环节和案例分析",
                "课程进度可以适当放缓，给学生更多消化时间",
                "期望提供更详细的课程大纲和学习路线图",
                "建议增加小组讨论和团队协作机会",
                "希望能提供更多课外学习资源和扩展阅读",
                "考核方式可以更加多元化，减少单一考试权重",
                "课堂互动形式可以更加多样化",
                "希望增加行业专家讲座或实地参观机会",
                "可以增加阶段性反馈和学习效果评估",
                "建议适当增加前沿技术和实际应用的介绍"
            ]
            
            import random
            import json
            
            # 使用JavaScript检测特定问题并填写相应内容
            js_code = """
            // 获取所有文本框
            var textAreas = document.querySelectorAll('textarea');
            var filledCount = 0;
            var questionTypes = [];
            
            if (textAreas.length > 0) {
                for (var i = 0; i < textAreas.length; i++) {
                    var textarea = textAreas[i];
                    var questionType = "general";
                    
                    // 尝试获取文本框的父元素，查找问题文本
                    var questionElement = textarea;
                    var foundQuestion = false;
                    var questionText = "";
                    
                    // 向上查找最多5层，尝试找到问题文本
                    for (var j = 0; j < 5; j++) {
                        if (!questionElement || questionElement === document.body) break;
                        
                        // 尝试在当前元素或其兄弟元素中查找问题文本
                        var possibleQuestions = [];
                        // 检查当前元素文本
                        if (questionElement.textContent) {
                            possibleQuestions.push(questionElement.textContent);
                        }
                        
                        // 检查兄弟元素
                        var siblings = questionElement.parentElement ? 
                            Array.from(questionElement.parentElement.children) : [];
                        
                        for (var k = 0; k < siblings.length; k++) {
                            if (siblings[k] !== questionElement && siblings[k].textContent) {
                                possibleQuestions.push(siblings[k].textContent);
                            }
                        }
                        
                        // 查找问题文本
                        for (var l = 0; l < possibleQuestions.length; l++) {
                            var text = possibleQuestions[l].trim();
                            if (text && text.length > 5) {  // 简单过滤掉太短的文本
                                // 检查是否包含特定关键词
                                if (text.includes("最满意") || text.includes("满意") && text.includes("方面")) {
                                    questionType = "satisfaction";
                                    questionText = text;
                                    foundQuestion = true;
                                    break;
                                } else if (text.includes("需要改进") || text.includes("改进") && text.includes("方面")) {
                                    questionType = "improvement";
                                    questionText = text;
                                    foundQuestion = true;
                                    break;
                                } else if (text.includes("意见") || text.includes("建议") || text.includes("评价")) {
                                    questionType = "general";
                                    questionText = text;
                                    foundQuestion = true;
                                }
                            }
                        }
                        
                        if (foundQuestion) break;
                        
                        // 向上一级继续查找
                        questionElement = questionElement.parentElement;
                    }
                    
                    // 记录问题类型
                    questionTypes.push({
                        index: i,
                        type: questionType,
                        text: questionText
                    });
                    
                    // 检查是否已有内容
                    if (!textarea.value || textarea.value === '无' || textarea.value.trim() === '') {
                        // 根据问题类型选择不同的文本
                        var textIndex = i < arguments.length ? i : 0;
                        var text = arguments[textIndex] || arguments[0];
                        
                        // 设置文本框的值
                        textarea.value = text;
                        
                        // 触发change事件
                        var event = new Event('change', { bubbles: true });
                        textarea.dispatchEvent(event);
                        
                        filledCount++;
                    }
                }
            }
            
            return {
                totalTextAreas: textAreas.length,
                filledCount: filledCount,
                questionTypes: questionTypes
            };
            """
            
            # 准备文本
            # 1. 为满意度问题选择回答
            satisfaction_text = "，".join(random.sample(satisfaction_suggestions, 2)) + "。"
            
            # 2. 为改进建议选择回答
            improvement_text = "，".join(random.sample(improvement_suggestions, 2)) + "。"
            
            # 3. 为一般问题选择回答
            general_text = "，".join(random.sample(suggestions, random.randint(3, 4))) + "。"
            
            # 执行JavaScript，填写文本框
            result = self.page.run_js(js_code, general_text, satisfaction_text, improvement_text)
            
            if result:
                question_types = result.get('questionTypes', [])
                logger.info(f"文本框填写完成: 共{result.get('totalTextAreas', 0)}个文本框，填写了{result.get('filledCount', 0)}个")
                
                for q in question_types:
                    q_type = q.get('type', 'unknown')
                    q_text = q.get('text', '').strip()
                    if q_type == 'satisfaction':
                        logger.info(f"检测到满意度问题: '{q_text[:30]}...'，填写满意度内容")
                    elif q_type == 'improvement':
                        logger.info(f"检测到改进建议问题: '{q_text[:30]}...'，填写改进建议内容")
                    else:
                        logger.info(f"检测到一般问题，填写一般建议内容")
                
                return result.get('filledCount', 0) > 0
            else:
                logger.warning("文本框填写返回结果为空")
                return False
                
        except Exception as e:
            logger.error(f"填写文本框时发生异常: {e}")
            return False

    def fill_evaluation_form(self) -> bool:
        """
        填写评教表单，按照要求选择表现突出(5星)和较好(4星)的比例为8:2，
        并在最后的总体满意度问题选择"非常满意"
        
        Returns:
            bool: 是否成功填写
        """
        if not self.page:
            logger.error("未设置页面对象")
            return False
        
        try:
            logger.info("开始快速填写评教表单")
            
            # 先填写文本输入框
            self.fill_text_areas()
            
            # 使用极简方法填写评教表单，直接处理所有radio按钮
            js_code = """
            // 获取所有radio按钮组
            var allRadioGroups = [];
            var satisfactionGroups = [];
            
            // 查找所有表单行
            var formItems = document.querySelectorAll('li.dxt, .question-item, tr');
            
            // 遍历所有行，查找具有radio按钮的行
            for (var i = 0; i < formItems.length; i++) {
                var item = formItems[i];
                var radios = item.querySelectorAll('input[type="radio"]');
                
                if (radios.length > 0) {
                    // 检查是否含有满意度问题
                    var itemText = item.textContent || '';
                    var isSatisfactionQuestion = itemText.indexOf('满意度') !== -1 || 
                                                itemText.indexOf('满意程度') !== -1 ||
                                                itemText.indexOf('满意') !== -1;
                    
                    if (isSatisfactionQuestion) {
                        satisfactionGroups.push({
                            item: item,
                            radios: radios,
                            text: itemText
                        });
                    } else {
                        // 检查是否包含"完全符合"或"符合"选项文本
                        var hasComplianceOptions = false;
                        var optionTexts = [];
                        
                        // 获取选项文本
                        var labels = item.querySelectorAll('label');
                        for (var l = 0; l < labels.length; l++) {
                            var labelText = labels[l].textContent.trim();
                            optionTexts.push(labelText);
                            if (labelText.indexOf('完全符合') !== -1 || labelText.indexOf('符合') !== -1) {
                                hasComplianceOptions = true;
                            }
                        }
                        
                        allRadioGroups.push({
                            item: item,
                            radios: radios,
                            text: itemText,
                            isCompliance: hasComplianceOptions,
                            optionTexts: optionTexts
                        });
                    }
                }
            }
            
            var totalClicked = 0;
            
            // 先处理满意度问题 - 全部选第一个选项（非常满意）
            for (var j = 0; j < satisfactionGroups.length; j++) {
                var group = satisfactionGroups[j];
                
                // 检查是否已有选中的radio
                var anyChecked = false;
                for (var k = 0; k < group.radios.length; k++) {
                    if (group.radios[k].checked) {
                        anyChecked = true;
                        break;
                    }
                }
                
                // 如果没有选中，则点击第一个选项（非常满意）
                if (!anyChecked && group.radios.length > 0) {
                    try {
                        group.radios[0].click();
                        totalClicked++;
                    } catch(e) {
                        // 忽略点击错误
                    }
                }
            }
            
            // 交替处理正常问题
            for (var m = 0; m < allRadioGroups.length; m++) {
                var radioGroup = allRadioGroups[m];
                
                // 检查是否已有选中的radio
                var isChecked = false;
                for (var n = 0; n < radioGroup.radios.length; n++) {
                    if (radioGroup.radios[n].checked) {
                        isChecked = true;
                        break;
                    }
                }
                
                // 如果没有选中，则交替选择
                if (!isChecked && radioGroup.radios.length > 0) {
                    try {
                        if (m % 2 === 0) {
                            // 偶数题号选择第一个选项（表现突出/完全符合）
                            radioGroup.radios[0].click();
                        } else {
                            // 奇数题号选择第二个选项（较好/符合），如果有的话
                            if (radioGroup.radios.length > 1) {
                                radioGroup.radios[1].click();
                            } else {
                                radioGroup.radios[0].click();
                            }
                        }
                        totalClicked++;
                    } catch(e) {
                        // 忽略点击错误
                    }
                }
            }
            
            return {
                totalRadioGroups: allRadioGroups.length,
                satisfactionGroups: satisfactionGroups.length,
                totalClicked: totalClicked
            };
            """
            
            result = self.page.run_js(js_code)
            
            if result:
                logger.info(f"快速填写完成: 共有{result.get('totalRadioGroups', 0)}个问题，{result.get('satisfactionGroups', 0)}个满意度问题，点击了{result.get('totalClicked', 0)}个选项")
                
                # 查找并点击提交按钮
                submit_js = """
                // 查找提交按钮
                var submitButton = null;
                
                // 方法1: 根据文本内容查找
                var buttons = document.querySelectorAll('button, input[type="submit"], input[type="button"]');
                for (var i = 0; i < buttons.length; i++) {
                    var btn = buttons[i];
                    var text = btn.textContent || btn.value || '';
                    if (text.indexOf('提交') !== -1 || text.indexOf('保存') !== -1) {
                        submitButton = btn;
                        break;
                    }
                }
                
                // 方法2: 根据class或id查找
                if (!submitButton) {
                    submitButton = document.querySelector('.submit, #submit, button.submit, input.submit');
                }
                
                // 点击提交按钮
                if (submitButton) {
                    submitButton.click();
                    return true;
                }
                
                return false;
                """
                
                submit_result = self.page.run_js(submit_js)
                
                if submit_result:
                    logger.info("已点击提交按钮")
                    return True
                else:
                    logger.warning("未找到提交按钮，尝试备用方法")
                    
                    # 备用方法查找提交按钮
                    submit_buttons = self.page.eles('xpath://button[contains(text(), "提交") or contains(text(), "保存")]')
                    if not submit_buttons:
                        submit_buttons = self.page.eles('xpath://input[@type="submit" or @type="button"][contains(@value, "提交") or contains(@value, "保存")]')
                    
                    if submit_buttons:
                        logger.info(f"找到 {len(submit_buttons)} 个提交按钮，点击第一个")
                        submit_buttons[0].click()
                        logger.info("已点击提交按钮")
                        return True
                    else:
                        logger.warning("未找到提交按钮")
                        return False
            else:
                logger.warning("快速填写返回结果为空")
                return False
                
        except Exception as e:
            logger.error(f"填写评教表单时发生异常: {e}")
            return False


def run_clicker(page):
    """
    运行评教点击器
    
    Args:
        page: DrissionPage页面对象
        
    Returns:
        bool: 是否成功点击
    """
    clicker = EvaluationClicker(page)
    success_count = 0
    max_attempts = 100  # 设置最大尝试次数，防止无限循环
    
    for attempt in range(max_attempts):
        click_success = clicker.click_evaluation_button()
        
        # 如果成功点击评价按钮并导航到评教表单页面，填写表单
        if click_success:
            form_filled = clicker.fill_evaluation_form()
            if form_filled:
                success_count += 1
            
            # 等待页面加载回到课程列表页面
            time.sleep(0.8)
            
            # 刷新页面以获取最新状态
            try:
                # 方法1: 使用page.refresh()方法刷新页面
                page.refresh()
                # 等待页面加载完成
                time.sleep(0.8)
            except Exception:
                # 备用方法: 重新加载当前URL
                try:
                    current_url = page.url
                    page.get(current_url)
                    time.sleep(0.8)
                except Exception:
                    pass
        else:
            break
    
    return success_count > 0


if __name__ == "__main__":
    pass  # 直接运行此脚本不会有实际效果，需要从evaluation_runner.py中调用 